var c;
(function () {
    var fn = {
        // 阻止冒泡
        stopBubble: function (e) {
            if (e && e.stopPropagation) {
                e.stopPropagation();
            }
            else {
                window.event.cancelBubble = true;
            }
        },
        UTF8: function () {
            this.encode = function (string) {
                var utftext = "";
                var byte = [];
                for (var n = 0; n < string.length; n++) {
                    var c = string.charCodeAt(n);//获取对应的unicode
                    if (c < 128) {
                        utftext += '\\x' + c.toString(16).toUpperCase();//单字节字符
                        byte.push(c);
                    }
                    else {
                        var byte_count = 2;
                        if (c > 127 && c < 2048)
                            byte_count = 2;
                        else if (c > 2047 && c < 65536)
                            byte_count = 3;
                        else if (c > 65535 && c < 1114112)
                            byte_count = 4;
                        else
                            return "编码失败！仅支持4位字节及以下的字符串编码！";


                        var height_code = '';
                        for (var j = 0; j < 8; j++) {
                            if (j < byte_count)
                                height_code += '1';
                            else
                                height_code += '0';
                        }


                        var d_code = parseInt(height_code, 2);
                        for (var i = byte_count - 1; i > -1; i--) {
                            var bit = i * 6;
                            if (i == byte_count - 1) {
                                var code = ((c >> bit) | d_code);
                                utftext += '\\x' + code.toString(16).toUpperCase();//按位右移6位获取到需要与高8位11000000也就是192进行补位的位数，然后通过按位或运算进行补位
                                byte.push(code)
                            }
                            else {
                                //63的二进制数是00000000 00111111，通过按位与运算获取后6位需要与低8位10000000进行补位的位数，然后或运算补位
                                var code = (((c >> bit) & 63) | 128);
                                utftext += '\\x' + code.toString(16).toUpperCase();
                                byte.push(code);
                            }

                        }
                    }
                }
                return utftext;
            }

            this.decode = function (utftext) {
                var string = "";
                //将utf8字符串分割成单个的十六进制
                var split = utftext.split('\\x');
                //删除第一个空字符串
                split.remove('');
                //对分割好的十六进制按照编码规则分组
                var group = [];
                var complete_binary_code = '';
                var count = -1;
                for (var i = 0; i < split.length; i++) {
                    var str = split[i];
                    var number = parseInt(str, 16);//转为10进制
                    var binary = number.toString(2);//转为二进制字符串
                    //不足8位的要进行补零
                    for (var j = 0; j < 8 - binary.length; j++) {
                        binary = binary.insert(0, '0');
                    }
                    var index = binary.indexOf('0');//查找第一个0出现的位置，也就是该组utf8的字节数
                    if (index > 0) {
                        if ((index > count && count != -1 && complete_binary_code != '')) {
                            //index > count 表明是第二个分组了，但是要排除count==-1的情况，因为这是循环的开始
                            group.push(complete_binary_code);
                            complete_binary_code = '';
                        }
                        else if (i == split.length - 1) {
                            //最后一个元素
                            complete_binary_code += binary.substr(index + 1, 7 - index);
                            group.push(complete_binary_code);
                        }
                        complete_binary_code += binary.substr(index + 1, 7 - index);
                        count = index;
                    }
                    else {
                        if (count != -1 && complete_binary_code != '')
                            group.push(complete_binary_code);//上一组的数据需要先保存
                        complete_binary_code = binary.substr(1, 7);
                        group.push(complete_binary_code);
                        complete_binary_code = '';
                    }
                }


                for (var i = 0; i < group.length; i++) {
                    var binary_str = group[i];
                    var char_code = parseInt(binary_str, 2);
                    string += String.fromCharCode(char_code);
                }
                return string;
            }
        },
        base64: function (params) {
            // var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
            var _keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-=";
            var utf8 = new UTF8();
            // public method for encoding  
            this.encode = function (input) {
                //转为utf8获取对应的字节数
                var utf8_str = utf8.encode(input);
                var bytes = utf8_str.split('\\x');
                //删除第一个空字符串
                // bytes.remove('')
                bytes.shift();
                var binary_code = "";
                for (var i = 0; i < bytes.length; i++) {
                    //转成10进制
                    var number = parseInt(bytes[i], 16);
                    //转成2进制
                    var baniry = number.toString(2);
                    //不足8位的进行补位
                    var length = baniry.length;
                    for (var j = 0; j < 8 - length; j++) {
                        // baniry = baniry.insert(0, "0");
                        baniry = '0' + baniry
                    }
                    binary_code += baniry;
                }

                var output = "";
                //获取based64字符数
                var base64_count = Math.ceil(binary_code.length / 6);
                var byte_remainder = binary_code.length % 6;
                byte_remainder = byte_remainder == 0 ? 6 : byte_remainder;
                for (var j = 0; j < (6 - byte_remainder); j++) {
                    //不足6位在后面追加0
                    binary_code += "0";
                }
                var i = 0;
                var dec_number = parseInt(binary_code, 2);
                var base64_remainder = base64_count % 4;
                base64_remainder = base64_remainder == 0 ? 4 : base64_remainder;
                while (i < (base64_count + (4 - base64_remainder))) {
                    //if (i < (4 - base64_remainder))
                    //    output += "=";
                    //else
                    //{
                    //    //思路一：采用逆序的处理逻辑进行编码，每次向右按位移动4 - base64_remainder位，再与63即（111111）进行按位与运算得到对应的数
                    //    //var bit = 6 * (i - (4 - base64_remainder));
                    //    //var index = (dec_number >> bit) & 63;
                    //    //var base64_code = _keyStr.substr(index, 1);
                    //    //output = output.insert(0, base64_code);
                    //    /*
                    //    注意：js的按位移动操作存在一个问题，对在int的范围（-2147483648～2147483647）内的十进制数进行按位移动操作是正常的
                    //    如：
                    //    var a = 2147483647;
                    //    var s = a.toString(2);
                    //    console.log(s);输出：1111111111111111111111111111111


                    //    var a = 2147483647 >> 0;
                    //    var s = a.toString(2);
                    //    console.log(s);输出：1111111111111111111111111111111


                    //    但是当十进制数超出了int的范围就会出问题，比如向右移动0位，按道理来说二进制数是不应该发生变化，但是结果却出乎我的意料
                    //    如：
                    //    var a = 26141406784;
                    //    var s = a.toString(2);
                    //    console.log(s); 输出：11000010110001001100011011001000000
                    //    但是如果对其进行按位移动操作之后就会出问题了
                    //    var a = 26141406784 >> 0;
                    //    var s = a.toString(2);
                    //    console.log(s); 输出：10110001001100011011001000000 这里的前面6位莫名奇妙的消失了，最大的可能就是js的按位运算
                    //    再如：
                    //    var a = -2147483649;
                    //    var s = a.toString(2);
                    //    console.log(s);输出：-10000000000000000000000000000001

                    //    var a = -2147483649 >> 0;
                    //    var s = a.toString(2);
                    //    console.log(s);输出：1111111111111111111111111111111 what？这是什么鬼！！
                    //    由于以上这个问题，思路一的方式是行不通的
                    //    */
                    //}
                    //i++;


                    //思路二：为要避免以上问题,我选择了截取对应的字符串的方式进行编码
                    if (i >= base64_count)
                        output += "=";
                    else {
                        var idx = 6 * i;
                        var code = binary_code.substr(idx, 6);
                        var index = parseInt(code, 2);
                        var base64_code = _keyStr.substr(index, 1);
                        output += base64_code;
                    }
                    i++;
                }
                return output;
            }


            // public method for decoding  
            this.decode = function (input) {
                var output = "";
                i = 0;
                var binary_code = "";
                while (i < input.length) {
                    var char = input.substr(i, 1);
                    var index = _keyStr.indexOf(char);
                    if (index == 64)
                        break;


                    var binary = index.toString(2);
                    var length = binary.length;
                    for (var j = 0; j < 6 - length; j++) {
                        binary = binary.insert(0, "0");
                    }

                    binary_code += binary;
                    i++;
                }
                var utf8_array = [];
                var byte_count = Math.floor(binary_code.length / 8);
                for (var j = 0; j < byte_count; j++) {
                    var code = binary_code.substr(j * 8, 8);
                    var dec_code = parseInt(code, 2);
                    utf8_array.push(dec_code.toString(16));
                }
                var utf8_str = utf8_array.join('\\x');
                output = utf8.decode(utf8_str);
                return output;
            }
        },
        // 阻止默认事件
        stopDefault: function (e) {
            if (e && e.preventDefault)
                e.preventDefault();
            else
                window.event.returnValue = false;
            return false;
        },
        // 字符串常规处理
        str: function (str, params) {
            var realLength = 0, len = str.length, charCode = -1, r = {};
            for (var i = 0; i < len; i++) {
                charCode = str.charCodeAt(i);
                if (charCode >= 0 && charCode <= 128)
                    realLength += 1;
                else
                    realLength += 2;
            }
            if (params)
                realLength > params.len ? r.content = (str.substr(0, params.len) + (params.content ? params.content : '...')) : r.content = realLength
            if (params)
                r.len = realLength
            else
                r = realLength
            return r;
        },
        // 获取滚动条高度
        scrollTop: function () {
            var scrollTop = 0;
            if (document.documentElement && document.documentElement.scrollTop) {
                scrollTop = document.documentElement.scrollTop;
            }
            else if (document.body) {
                scrollTop = document.body.scrollTop;
            }
            return scrollTop;
        },
        //  获取目标元素距离顶部高度
        offsetTop: function (elements) {
            var top = elements.offsetTop;
            var parent = elements.offsetParent;
            while (parent != null) {
                top += parent.offsetTop;
                parent = parent.offsetParent;
            };
            return top;
        },
        getCookies(name) {
            var arr = document.cookie.split('; ')
            for (var i = 0; i < arr.length; i++) {
                var arr2 = arr[i].split('=')
                if (arr2[0] == name) {
                    return arr2[1]
                }
            }
            return ''
        },
        // 深拷贝对象
        copyObj: function (obj) {
            var tmp = {}
            for (var i in obj)
                tmp[i] = obj[i]
            return tmp
        },
        // 删除数组指定位置
        removeArrayTarget: function (arr, val) {
            var tmp = arr
            for (var i = 0; i < tmp.length; i++) {
                if (tmp[i] == val)
                    tmp.splice(i, 1)
            }
            return tmp
        },
        // 无bug保佑_1
        bless_1: function () {
            console.log([
                '*----------Dragon be here!----------/',
                '* 　　　┏┓　　　┏┓',
                '* 　　┏┛┻━━━┛┻┓',
                '* 　　┃　　　　　　　┃',
                '* 　　┃　　　━　　　┃',
                '* 　　┃　┳┛　┗┳　┃',
                '* 　　┃　　　　　　　┃',
                '* 　　┃　　　┻　　　┃',
                '* 　　┃　　　　　　　┃',
                '* 　　┗━┓　　　┏━┛',
                '* 　　　　┃　　　┃神兽保佑',
                '* 　　　　┃　　　┃代码无BUG！',
                '* 　　　　┃　　　┗━━━┓',
                '* 　　　　┃　　　　　　　┣┓',
                '* 　　　　┃　　　　　　　┏┛',
                '* 　　　　┗┓┓┏━┳┓┏┛',
                '* 　　　　　┃┫┫　┃┫┫',
                '* 　　　　　┗┻┛　┗┻┛',
                '* ━━━━━━神兽出没━━━━━━',
            ].join('\n'));
        },
        // 无bug保佑_2
        bless_2: function () {
            console.log([
                "                   _ooOoo_",
                "                  o8888888o",
                "                  88\" . \"88",
                "                  (| -_- |)",
                "                  O\\  =  /O",
                "               ____/`---'\\____",
                "             .'  \\\\|     |//  `.",
                "            /  \\\\|||  :  |||//  \\",
                "           /  _||||| -:- |||||-  \\",
                "           |   | \\\\\\  -  /// |   |",
                "           | \\_|  ''\\---/''  |   |",
                "           \\  .-\\__  `-`  ___/-. /",
                "         ___`. .'  /--.--\\  `. . __",
                "      .\"\" '<  `.___\\_<|>_/___.'  >'\"\".",
                "     | | :  `- \\`.;`\\ _ /`;.`/ - ` : | |",
                "     \\  \\ `-.   \\_ __\\ /__ _/   .-` /  /",
                "======`-.____`-.___\\_____/___.-`____.-'======",
                "                   `=---='",
                "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^",
                "         佛祖保佑       永无BUG"
            ].join('\n'));
        }
    }
    c = fn
})()